পাইথনের ইটারেটর প্রোটোকল উন্মোচন: __iter__ এবং __next__ এর গভীরে

ইটারেশন প্রোগ্রামিংয়ের অন্যতম মৌলিক ধারণা। পাইথনে, এটি একটি মার্জিত এবং দক্ষ প্রক্রিয়া যা সাধারণ for লুপ থেকে শুরু করে জটিল ডেটা প্রক্রিয়াকরণ পাইপলাইন পর্যন্ত সবকিছুকে শক্তি যোগায়। আপনি প্রতিদিন এটি ব্যবহার করেন যখন আপনি একটি তালিকার মাধ্যমে লুপ করেন, একটি ফাইল থেকে লাইন পড়েন, বা ডাটাবেস ফলাফলের সাথে কাজ করেন। কিন্তু আপনি কি কখনও ভেবে দেখেছেন যে পর্দার আড়ালে কী ঘটছে? পাইথন কীভাবে জানে যে এত বিভিন্ন ধরণের অবজেক্ট থেকে কীভাবে 'পরবর্তী' আইটেমটি পেতে হয়?

উত্তরটি একটি শক্তিশালী এবং মার্জিত ডিজাইন প্যাটার্নের মধ্যে নিহিত, যা ইটারেটর প্রোটোকল নামে পরিচিত। এই প্রোটোকলটি হল সাধারণ ভাষা যা পাইথনের সমস্ত সিকোয়েন্স-সদৃশ অবজেক্ট ব্যবহার করে। এই প্রোটোকলটি বোঝা এবং বাস্তবায়ন করে, আপনি আপনার নিজস্ব কাস্টম অবজেক্ট তৈরি করতে পারেন যা পাইথনের ইটারেশন সরঞ্জামগুলির সাথে সম্পূর্ণরূপে সামঞ্জস্যপূর্ণ, যা আপনার কোডকে আরও বেশি প্রকাশক, মেমরি-সাশ্রয়ী এবং বিশেষভাবে 'পাইথোনিক' করে তোলে।

এই বিস্তৃত গাইডটি আপনাকে ইটারেটর প্রোটোকলের গভীরে নিয়ে যাবে। আমরা `__iter__` এবং `__next__` মেথডগুলির পেছনের জাদু উন্মোচন করব, একটি ইটারেবল এবং একটি ইটারেটরের মধ্যে গুরুত্বপূর্ণ পার্থক্য স্পষ্ট করব এবং স্ক্র্যাচ থেকে আপনার নিজস্ব কাস্টম ইটারেটর তৈরি করার প্রক্রিয়ার মধ্য দিয়ে যাব। আপনি যদি পাইথনের অভ্যন্তরীণ বিষয়গুলির গভীরতা বুঝতে চান এমন একজন মধ্যবর্তী ডেভেলপার হন বা আরও অত্যাধুনিক API ডিজাইন করার লক্ষ্যে একজন বিশেষজ্ঞ হন, তাহলে ইটারেটর প্রোটোকল আয়ত্ত করা আপনার যাত্রার একটি গুরুত্বপূর্ণ পদক্ষেপ।

'কেন': ইটারেশনের গুরুত্ব এবং ক্ষমতা

আমরা প্রযুক্তিগত বাস্তবায়নে ডুব দেওয়ার আগে, ইটারেটর প্রোটোকল কেন এত গুরুত্বপূর্ণ তা উপলব্ধি করা অপরিহার্য। এর সুবিধাগুলি কেবল `for` লুপগুলিকে সক্ষম করার চেয়েও অনেক বেশি।

মেমরি দক্ষতা এবং অলস মূল্যায়ন

কল্পনা করুন যে আপনাকে একটি বিশাল লগ ফাইল প্রক্রিয়াকরণের প্রয়োজন যা কয়েক গিগাবাইট আকারের। আপনি যদি পুরো ফাইলটিকে মেমরিতে একটি তালিকায় লোড করেন, তবে সম্ভবত আপনার সিস্টেমের সংস্থান শেষ হয়ে যাবে। ইটারেটররা অলস মূল্যায়ন নামক একটি ধারণার মাধ্যমে এই সমস্যাটি সুন্দরভাবে সমাধান করে।

একটি ইটারেটর একবারে সমস্ত ডেটা লোড করে না। পরিবর্তে, এটি শুধুমাত্র অনুরোধ করা হলেই একবারে একটি আইটেম তৈরি করে বা নিয়ে আসে। এটি সিকোয়েন্সে কোথায় আছে তা মনে রাখার জন্য একটি অভ্যন্তরীণ অবস্থা বজায় রাখে। এর মানে হল আপনি খুব ছোট, ধ্রুবক পরিমাণ মেমরি দিয়ে (তত্ত্বগতভাবে) অসীমভাবে বৃহৎ ডেটা স্ট্রিম প্রক্রিয়া করতে পারেন। এটি একই নীতি যা আপনাকে আপনার প্রোগ্রাম ক্র্যাশ না করে একটি বিশাল ফাইল লাইন-বাই-লাইন পড়তে দেয়।

পরিষ্কার, পঠনযোগ্য এবং সার্বজনীন কোড

ইটারেটর প্রোটোকল ক্রমিক অ্যাক্সেসের জন্য একটি সার্বজনীন ইন্টারফেস সরবরাহ করে। যেহেতু তালিকা, টাপল, অভিধান, স্ট্রিং, ফাইল অবজেক্ট এবং অন্যান্য অনেক প্রকার এই প্রোটোকল মেনে চলে, তাই আপনি এই সবগুলির সাথে কাজ করার জন্য একই সিনট্যাক্স—`for` লুপ—ব্যবহার করতে পারেন। এই অভিন্নতা পাইথনের পঠনযোগ্যতার একটি ভিত্তি।

এই কোডটি বিবেচনা করুন:

কোড:

my_list = [1, 2, 3]
for item in my_list:
    print(item)

my_string = "abc"
for char in my_string:
    print(char)

with open('my_file.txt', 'r') as f:
    for line in f:
        print(line)

`for` লুপ চিন্তা করে না যে এটি পূর্ণসংখ্যার একটি তালিকা, অক্ষরের একটি স্ট্রিং, নাকি একটি ফাইল থেকে লাইনগুলির উপর পুনরাবৃত্তি করছে। এটি কেবল অবজেক্টটিকে তার ইটারেটরের জন্য জিজ্ঞাসা করে এবং তারপরে বারবার ইটারেটরকে তার পরবর্তী আইটেমের জন্য জিজ্ঞাসা করে। এই বিমূর্ততা অবিশ্বাস্যভাবে শক্তিশালী।

ইটারেটর প্রোটোকলকে ভেঙে ফেলা

প্রোটোকলটি নিজেই আশ্চর্যজনকভাবে সহজ, শুধুমাত্র দুটি বিশেষ মেথড দ্বারা সংজ্ঞায়িত, প্রায়শই "ডান্ডার" (ডাবল আন্ডারস্কোর) মেথড বলা হয়:

• `__iter__()`
• `__next__()`

এগুলি সম্পূর্ণরূপে উপলব্ধি করার জন্য, আমাদের প্রথমে দুটি সম্পর্কিত তবে ভিন্ন ধারণার মধ্যে পার্থক্য বুঝতে হবে: একটি ইটারেবল এবং একটি ইটারেটর।

ইটারেবল বনাম ইটারেটর: একটি গুরুত্বপূর্ণ পার্থক্য

নতুনদের জন্য এটি প্রায়শই বিভ্রান্তির কারণ হয়, তবে পার্থক্যটি অত্যন্ত গুরুত্বপূর্ণ।

ইটারেবল কী?

একটি ইটারেবল হল যেকোনো অবজেক্ট যা লুপ করা যেতে পারে। এটি এমন একটি অবজেক্ট যা আপনি একটি ইটারেটর পেতে অন্তর্নির্মিত `iter()` ফাংশনে পাস করতে পারেন। প্রযুক্তিগতভাবে, একটি অবজেক্টকে ইটারেবল হিসাবে বিবেচনা করা হয় যদি এটি `__iter__` মেথডটি প্রয়োগ করে। এর `__iter__` মেথডের একমাত্র উদ্দেশ্য হল একটি ইটারেটর অবজেক্ট ফেরত দেওয়া।

অন্তর্নির্মিত ইটারেবলগুলির উদাহরণগুলির মধ্যে রয়েছে:

• তালিকা (`[1, 2, 3]`)
• টাপল (`(1, 2, 3)`)
• স্ট্রিং (`"hello"`)
• অভিধান (`{'a': 1, 'b': 2}` - কীগুলির উপর পুনরাবৃত্তি করে)
• সেট (`{1, 2, 3}`)
• ফাইল অবজেক্ট

আপনি একটি ইটারেবলকে ডেটার একটি ধারক বা উৎস হিসাবে ভাবতে পারেন। এটি নিজে থেকে আইটেম তৈরি করতে জানে না, তবে এটি জানে যে কীভাবে একটি অবজেক্ট তৈরি করতে হয় যা তা করতে পারে: ইটারেটর।

ইটারেটর কী?

একটি ইটারেটর হল সেই অবজেক্ট যা প্রকৃতপক্ষে ইটারেশনের সময় মান তৈরি করার কাজ করে। এটি ডেটার একটি স্ট্রিম উপস্থাপন করে। একটি ইটারেটরকে অবশ্যই দুটি মেথড বাস্তবায়ন করতে হবে:

• `__iter__()`: এই মেথডটি ইটারেটর অবজেক্টটি নিজেই (`self`) ফেরত দেওয়া উচিত। এটি প্রয়োজনীয় যাতে ইটারেটরগুলিকেও ব্যবহার করা যায় যেখানে ইটারেবলগুলি প্রত্যাশিত, উদাহরণস্বরূপ, একটি `for` লুপে।
• `__next__()`: এই মেথডটি ইটারেটরের ইঞ্জিন। এটি সিকোয়েন্সের পরবর্তী আইটেমটি ফেরত দেয়। যখন ফেরত দেওয়ার জন্য আর কোনও আইটেম থাকে না, তখন এটি অবশ্যই `StopIteration` ব্যতিক্রম উত্থাপন করবে। এই ব্যতিক্রমটি কোনও ত্রুটি নয়; এটি লুপ গঠনকে স্ট্যান্ডার্ড সংকেত যে ইটারেশন সম্পূর্ণ।

একটি ইটারেটরের মূল বৈশিষ্ট্যগুলি হল:

• এটি অবস্থা বজায় রাখে: একটি ইটারেটর সিকোয়েন্সে তার বর্তমান অবস্থান মনে রাখে।
• এটি একবারে একটি করে মান তৈরি করে: `__next__` মেথডের মাধ্যমে।
• এটি নিঃশেষযোগ্য: একবার একটি ইটারেটর সম্পূর্ণরূপে গ্রাস হয়ে গেলে (অর্থাৎ, এটি `StopIteration` উত্থাপন করেছে), এটি খালি। আপনি এটি পুনরায় সেট বা পুনরায় ব্যবহার করতে পারবেন না। আবার পুনরাবৃত্তি করতে, আপনাকে অবশ্যই মূল ইটারেবলে ফিরে যেতে হবে এবং আবার এটির উপর `iter()` কল করে একটি নতুন ইটারেটর পেতে হবে।

আমাদের প্রথম কাস্টম ইটারেটর তৈরি করা: একটি ধাপে ধাপে গাইড

তত্ত্ব দুর্দান্ত, তবে প্রোটোকলটি বোঝার সেরা উপায় হল এটি নিজে তৈরি করা। আসুন একটি সাধারণ ক্লাস তৈরি করি যা একটি কাউন্টার হিসাবে কাজ করে, একটি শুরু সংখ্যা থেকে একটি সীমা পর্যন্ত পুনরাবৃত্তি করে।

উদাহরণ 1: একটি সাধারণ কাউন্টার ক্লাস

আমরা `CountUpTo` নামে একটি ক্লাস তৈরি করব। আপনি যখন এর একটি উদাহরণ তৈরি করবেন, আপনি একটি সর্বোচ্চ সংখ্যা নির্দিষ্ট করবেন এবং আপনি যখন এটির উপর পুনরাবৃত্তি করবেন, তখন এটি 1 থেকে সেই সর্বোচ্চ সংখ্যা পর্যন্ত সংখ্যাগুলি প্রদান করবে।

কোড:

class CountUpTo:
    """An iterator that counts from 1 up to a specified maximum number."""

    def __init__(self, max_num):
        print("Initializing the CountUpTo object...")
        self.max_num = max_num
        self.current = 0 # This will store the state
    def __iter__(self):
        print("__iter__ called, returning self...")
        # This object is its own iterator, so we return self
        return self
    def __next__(self):
        print("__next__ called...")
        if self.current < self.max_num:
            self.current += 1
            return self.current
        else:
            # This is the crucial part: signal that we are done.             print("Raising StopIteration.")
            raise StopIteration
# How to use it print("Creating the counter object...")
counter = CountUpTo(3)

print("\nStarting the for loop...")
for number in counter:
    print(f"For loop received: {number}")

কোড ব্রেকডাউন এবং ব্যাখ্যা

আসুন বিশ্লেষণ করি যখন `for` লুপটি চলে তখন কী ঘটে:

1. ইনিশিয়ালাইজেশন: `counter = CountUpTo(3)` আমাদের ক্লাসের একটি উদাহরণ তৈরি করে। `__init__` মেথডটি চলে, `self.max_num` কে 3 এবং `self.current` কে 0 এ সেট করে। আমাদের অবজেক্টের অবস্থা এখন ইনিশিয়ালাইজ করা হয়েছে।
2. লুপ শুরু করা: যখন `for number in counter:` লাইনটি পৌঁছায়, তখন পাইথন অভ্যন্তরীণভাবে `iter(counter)` কল করে।
3. `__iter__` কল করা হয়: `iter(counter)` কলটি আমাদের `counter.__iter__()` মেথডটিকে আহ্বান করে। আপনি আমাদের কোড থেকে দেখতে পাচ্ছেন, এই মেথডটি কেবল একটি বার্তা প্রিন্ট করে এবং `self` ফেরত দেয়। এটি `for` লুপকে বলে, "আপনাকে `__next__` কল করতে হবে এমন অবজেক্টটি আমিই!"
4. লুপ শুরু হয়: এখন `for` লুপ প্রস্তুত। প্রতিটি ইটারেশনে, এটি প্রাপ্ত ইটারেটর অবজেক্টের উপর `next()` কল করবে (যা আমাদের `counter` অবজেক্ট)।
5. প্রথম `__next__` কল: `counter.__next__()` মেথডটি কল করা হয়। `self.current` হল 0, যা `self.max_num` (3) এর চেয়ে কম। কোডটি `self.current` কে 1 এ বাড়িয়ে দেয় এবং এটি ফেরত দেয়। `for` লুপ এই মানটিকে `number` ভেরিয়েবলে অর্পণ করে এবং লুপ বডি (`print(...)`) কার্যকর করে।
6. দ্বিতীয় `__next__` কল: লুপ চলতে থাকে। `__next__` আবার কল করা হয়। `self.current` হল 1। এটি 2 তে বৃদ্ধি করা হয় এবং ফেরত দেওয়া হয়।
7. তৃতীয় `__next__` কল: `__next__` আবার কল করা হয়। `self.current` হল 2। এটি 3 তে বৃদ্ধি করা হয় এবং ফেরত দেওয়া হয়।
8. শেষ `__next__` কল: `__next__` আরও একবার কল করা হয়। এখন, `self.current` হল 3। শর্ত `self.current < self.max_num` মিথ্যা। `else` ব্লকটি কার্যকর করা হয় এবং `StopIteration` উত্থাপন করা হয়।
9. লুপ শেষ করা: `for` লুপটি `StopIteration` ব্যতিক্রমটি ধরার জন্য ডিজাইন করা হয়েছে। যখন এটি তা করে, তখন এটি জানতে পারে যে ইটারেশন শেষ হয়েছে এবং সুন্দরভাবে সমাপ্ত হয়। প্রোগ্রামটি লুপের পরে যেকোনো কোড কার্যকর করা চালিয়ে যায়।

একটি মূল বিবরণ লক্ষ্য করুন: আপনি যদি একই `counter` অবজেক্টে আবার `for` লুপ চালানোর চেষ্টা করেন তবে এটি কাজ করবে না। ইটারেটর নিঃশেষ হয়ে গেছে। `self.current` ইতিমধ্যে 3, তাই `__next__` এ যেকোনো পরবর্তী কল অবিলম্বে `StopIteration` উত্থাপন করবে। এটি আমাদের অবজেক্টকে তার নিজের ইটারেটর করার ফলস্বরূপ।

উন্নত ইটারেটর ধারণা এবং বাস্তব-বিশ্বের অ্যাপ্লিকেশন

সাধারণ কাউন্টার শেখার একটি দুর্দান্ত উপায়, তবে ইটারেটর প্রোটোকলের আসল শক্তি আরও জটিল, কাস্টম ডেটা স্ট্রাকচারে প্রয়োগ করা হলে প্রকাশ পায়।

ইটারেবল এবং ইটারেটরকে একত্রিত করার সমস্যা

আমাদের `CountUpTo` উদাহরণে, ক্লাসটি ইটারেবল এবং ইটারেটর উভয়ই ছিল। এটি সহজ তবে একটি বড় ত্রুটি রয়েছে: ফলস্বরূপ ইটারেটরটি নিঃশেষযোগ্য। একবার আপনি এটির উপর লুপ করলে, এটি শেষ।

কোড:

counter = CountUpTo(2)
print("First iteration:")
for num in counter: print(num) # Works fine
print("\nSecond iteration:")
for num in counter: print(num) # Prints nothing!

এটি ঘটে কারণ অবস্থা (`self.current`) অবজেক্টটিতে নিজেই সংরক্ষণ করা হয়। প্রথম লুপের পরে, `self.current` হল 2, এবং আরও `__next__` কলগুলি কেবল `StopIteration` উত্থাপন করবে। এই আচরণটি একটি স্ট্যান্ডার্ড পাইথন তালিকা থেকে আলাদা, যা আপনি একাধিকবার পুনরাবৃত্তি করতে পারেন।

আরও শক্তিশালী প্যাটার্ন: ইটারেবলকে ইটারেটর থেকে আলাদা করা

পাইথনের অন্তর্নির্মিত সংগ্রহগুলির মতো পুনরায় ব্যবহারযোগ্য ইটারেবল তৈরি করতে, সর্বোত্তম অনুশীলন হল দুটি ভূমিকাকে আলাদা করা। ধারক অবজেক্টটি ইটারেবল হবে এবং প্রতিটি সময় তার `__iter__` মেথড কল করা হলে এটি একটি নতুন, নতুন ইটারেটর অবজেক্ট তৈরি করবে।

আসুন আমাদের উদাহরণটিকে দুটি ক্লাসে পুনরায় ফ্যাক্টর করি: `Sentence` (ইটারেবল) এবং `SentenceIterator` (ইটারেটর)।

কোড:

class SentenceIterator:
    """The iterator responsible for state and producing values."""
    def __init__(self, words):
        self.words = words
        self.index = 0
    def __next__(self):
        try:
            word = self.words[self.index]
        except IndexError:
            raise StopIteration()
        self.index += 1
        return word
    def __iter__(self):
        # An iterator must also be an iterable, returning itself.
        return self
class Sentence:
    """The iterable container class."""
    def __init__(self, text):
        # The container holds the data.         self.words = text.split()
    def __iter__(self):
        # Each time __iter__ is called, it creates a NEW iterator object.
        return SentenceIterator(self.words)
# How to use it my_sentence = Sentence('This is a test')
print("First iteration:")
for word in my_sentence:
    print(word)
print("\nSecond iteration:")
for word in my_sentence:
    print(word)

এখন, এটি একটি তালিকার মতোই কাজ করে! প্রতিটি সময় `for` লুপ শুরু হয়, এটি `my_sentence.__iter__()` কল করে, যা তার নিজস্ব অবস্থা (`self.index = 0`) সহ একটি নতুন `SentenceIterator` উদাহরণ তৈরি করে। এটি একই `Sentence` অবজেক্টের উপর একাধিক, স্বাধীন ইটারেশনের জন্য অনুমতি দেয়। এই প্যাটার্নটি আরও অনেক বেশি শক্তিশালী এবং এটি হল পাইথনের নিজস্ব সংগ্রহগুলি কীভাবে প্রয়োগ করা হয়।

উদাহরণ: অসীম ইটারেটর

ইটারেটরগুলিকে সসীম হতে হবে না। তারা ডেটার একটি অন্তহীন ক্রম উপস্থাপন করতে পারে। এখানেই তাদের অলস, একবারে একটি প্রকৃতির একটি বিশাল সুবিধা। আসুন ফিবোনাচি সংখ্যার একটি অসীম ক্রমের জন্য একটি ইটারেটর তৈরি করি।

কোড:

class FibonacciIterator:
    """Generates an infinite sequence of Fibonacci numbers."""
    def __init__(self):
        self.a, self.b = 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        result = self.a
        self.a, self.b = self.b, self.a + self.b
        return result
# How to use it - CAUTION: Infinite loop without a break!
fib_gen = FibonacciIterator()

for i, num in enumerate(fib_gen):
    print(f"Fibonacci({i}): {num}")
    if i >= 10: # We must provide a stopping condition         break

এই ইটারেটরটি নিজে থেকে কখনও `StopIteration` উত্থাপন করবে না। লুপটি শেষ করার জন্য একটি শর্ত (যেমন একটি `break` স্টেটমেন্ট) সরবরাহ করা কলিং কোডের দায়িত্ব। এই প্যাটার্নটি ডেটা স্ট্রিমিং, ইভেন্ট লুপ এবং সংখ্যাসূচক সিমুলেশনে সাধারণ।

পাইথন ইকোসিস্টেমে ইটারেটর প্রোটোকল

`__iter__` এবং `__next__` বোঝা আপনাকে পাইথনে সর্বত্র তাদের প্রভাব দেখতে দেয়। এটি ইউনিফাইং প্রোটোকল যা পাইথনের অনেকগুলি বৈশিষ্ট্যকে একসাথে নির্বিঘ্নে কাজ করে তোলে।

`for` লুপগুলি *সত্যিই* কীভাবে কাজ করে

আমরা পরোক্ষভাবে এটি নিয়ে আলোচনা করেছি, তবে আসুন এটি স্পষ্ট করি। পাইথন যখন এই লাইনটি সম্মুখীন হয়:

`for item in my_iterable:`

তখন এটি পর্দার আড়ালে নিম্নলিখিত পদক্ষেপগুলি সম্পাদন করে:

1. এটি একটি ইটারেটর পেতে `iter(my_iterable)` কল করে। এটি পরিবর্তে `my_iterable.__iter__()` কল করে। আসুন ফেরত দেওয়া অবজেক্টটিকে `iterator_obj` বলি।
2. এটি একটি অসীম `while True` লুপে প্রবেশ করে।
3. লুপের ভিতরে, এটি `next(iterator_obj)` কল করে, যা পরিবর্তে `iterator_obj.__next__()` কল করে।
4. যদি `__next__` একটি মান ফেরত দেয় তবে এটি `item` ভেরিয়েবলে অর্পণ করা হয় এবং `for` লুপ ব্লকের ভিতরে কোডটি কার্যকর করা হয়।
5. যদি `__next__` একটি `StopIteration` ব্যতিক্রম উত্থাপন করে, `for` লুপ এই ব্যতিক্রমটি ধরে এবং তার অভ্যন্তরীণ `while` লুপ থেকে বেরিয়ে আসে। ইটারেশন সম্পূর্ণ।

কম্প্রিহেনশন এবং জেনারেটর এক্সপ্রেশন

তালিকা, সেট এবং অভিধান কমপ্রিহেনশন সবই ইটারেটর প্রোটোকল দ্বারা চালিত। আপনি যখন লেখেন:

`squares = [x * x for x in range(10)]`

তখন পাইথন কার্যকরভাবে `range(10)` অবজেক্টের উপর একটি ইটারেশন সম্পাদন করে, প্রতিটি মান পায় এবং তালিকা তৈরি করতে `x * x` এক্সপ্রেশনটি কার্যকর করে। জেনারেটর এক্সপ্রেশনগুলির ক্ষেত্রেও একই কথা প্রযোজ্য, যা অলস ইটারেশনের আরও সরাসরি ব্যবহার:

`lazy_squares = (x * x for x in range(1000000))`

এটি মেমরিতে একটি মিলিয়ন-আইটেমের তালিকা তৈরি করে না। এটি একটি ইটারেটর তৈরি করে (বিশেষত, একটি জেনারেটর অবজেক্ট) যা আপনি এটির উপর পুনরাবৃত্তি করার সাথে সাথে একের পর এক স্কোয়ার গণনা করবে।

জেনারেটর: ইটারেটর তৈরি করার সহজ উপায়

যদিও `__iter__` এবং `__next__` সহ একটি সম্পূর্ণ ক্লাস তৈরি করা আপনাকে সর্বাধিক নিয়ন্ত্রণ দেয় তবে এটি সাধারণ ক্ষেত্রেগুলির জন্য ভার্বোস হতে পারে। পাইথন ইটারেটর তৈরি করার জন্য আরও সংক্ষিপ্ত সিনট্যাক্স সরবরাহ করে: জেনারেটর।

একটি জেনারেটর হল একটি ফাংশন যা `yield` কীওয়ার্ড ব্যবহার করে। আপনি যখন একটি জেনারেটর ফাংশন কল করেন, তখন এটি কোড চালায় না। পরিবর্তে, এটি একটি জেনারেটর অবজেক্ট ফেরত দেয়, যা একটি সম্পূর্ণ ইটারেটর।

আসুন আমাদের `CountUpTo` উদাহরণটিকে একটি জেনারেটর হিসাবে পুনরায় লিখি:

কোড:

def count_up_to_generator(max_num):
    """A generator function that yields numbers from 1 to max_num."""
    print("Generator started...")
    current = 1
    while current <= max_num:
        yield current # Pauses here and sends a value back         current += 1
    print("Generator finished.")
# How to use it
counter_gen = count_up_to_generator(3)
for number in counter_gen:
    print(f"For loop received: {number}")

দেখুন এটি কতটা সহজ! এখানে `yield` কীওয়ার্ডটি জাদু। যখন `yield` সম্মুখীন হয়, তখন ফাংশনের অবস্থা হিমায়িত হয়ে যায়, মানটি কলারের কাছে প্রেরণ করা হয় এবং ফাংশনটি বিরতি দেয়। জেনারেটর অবজেক্টে পরবর্তী সময়ে যখন `__next__` কল করা হয়, তখন ফাংশনটি ঠিক যেখানে ছেড়ে গিয়েছিল সেখান থেকে আবার শুরু হয়, যতক্ষণ না এটি অন্য `yield` বা ফাংশন শেষ না হয়। যখন ফাংশনটি শেষ হয়, তখন আপনার জন্য স্বয়ংক্রিয়ভাবে একটি `StopIteration` উত্থাপন করা হয়।

পর্দার আড়ালে, পাইথন স্বয়ংক্রিয়ভাবে `__iter__` এবং `__next__` মেথড সহ একটি অবজেক্ট তৈরি করেছে। যদিও জেনারেটরগুলি প্রায়শই আরও ব্যবহারিক পছন্দ, তবে অন্তর্নিহিত প্রোটোকল বোঝা ডিবাগিং, জটিল সিস্টেম ডিজাইন করা এবং পাইথনের মূল মেকানিক্স কীভাবে কাজ করে তা উপলব্ধি করার জন্য প্রয়োজনীয়।

সেরা অনুশীলন এবং সাধারণ ত্রুটি

ইটারেটর প্রোটোকল প্রয়োগ করার সময়, সাধারণ ত্রুটিগুলি এড়াতে এই নির্দেশিকাগুলি মনে রাখবেন।

সেরা অনুশীলন

• ইটারেবল এবং ইটারেটরকে আলাদা করুন: যেকোনো ধারক অবজেক্টের জন্য যা একাধিক ট্র্যাভার্স সমর্থন করা উচিত, সর্বদা একটি পৃথক ক্লাসে ইটারেটর প্রয়োগ করুন। ধারকের `__iter__` মেথডটি প্রতিটি সময় ইটারেটর ক্লাসের একটি নতুন উদাহরণ ফেরত দেওয়া উচিত।
• সর্বদা `StopIteration` উত্থাপন করুন: `__next__` মেথডটিকে অবশ্যই শেষের সংকেত দেওয়ার জন্য নির্ভরযোগ্যভাবে `StopIteration` উত্থাপন করতে হবে। এটি ভুলে গেলে অসীম লুপ হবে।
• ইটারেটরগুলিকে ইটারেবল হওয়া উচিত: একটি ইটারেটরের `__iter__` মেথডটি সর্বদা `self` ফেরত দেওয়া উচিত। এটি একটি ইটারেটরকে যেকোনো জায়গায় ব্যবহার করার অনুমতি দেয় যেখানে একটি ইটারেবল প্রত্যাশিত।
• সরলতার জন্য জেনারেটরগুলিকে পছন্দ করুন: যদি আপনার ইটারেটর লজিক সরল হয় এবং এটিকে একটি একক ফাংশন হিসাবে প্রকাশ করা যায় তবে একটি জেনারেটর প্রায় সর্বদা পরিষ্কার এবং আরও পঠনযোগ্য। যখন আপনার ইটারেটর অবজেক্টের সাথে আরও জটিল অবস্থা বা মেথড যুক্ত করার প্রয়োজন হয় তখন একটি সম্পূর্ণ ইটারেটর ক্লাস ব্যবহার করুন।

সাধারণ ত্রুটি

• নিঃশেষযোগ্য ইটারেটর সমস্যা: আলোচনা করা হয়েছে, সচেতন থাকুন যে যখন কোনও অবজেক্ট তার নিজের ইটারেটর হয়, তখন এটি কেবল একবার ব্যবহার করা যেতে পারে। যদি আপনাকে একাধিকবার পুনরাবৃত্তি করতে হয় তবে আপনাকে হয় একটি নতুন উদাহরণ তৈরি করতে হবে বা পৃথক ইটারেবল/ইটারেটর প্যাটার্ন ব্যবহার করতে হবে।
• অবস্থা ভুলে যাওয়া: `__next__` মেথডটিকে অবশ্যই ইটারেটরের অভ্যন্তরীণ অবস্থা পরিবর্তন করতে হবে (যেমন, একটি সূচক বৃদ্ধি করা বা একটি পয়েন্টারকে এগিয়ে নেওয়া)। যদি অবস্থা আপডেট না করা হয় তবে `__next__` বারবার একই মান ফেরত দেবে, সম্ভবত একটি অসীম লুপ তৈরি করবে।
• পুনরাবৃত্তি করার সময় একটি সংগ্রহ পরিবর্তন করা: পুনরাবৃত্তি করার সময় একটি সংগ্রহ পরিবর্তন করা (উদাহরণস্বরূপ, `for` লুপের ভিতরে একটি তালিকা থেকে আইটেম সরানো যা এটির উপর পুনরাবৃত্তি করছে) অপ্রত্যাশিত আচরণের দিকে পরিচালিত করতে পারে, যেমন আইটেমগুলি এড়িয়ে যাওয়া বা অপ্রত্যাশিত ত্রুটি উত্থাপন করা। আপনি যদি মূলটি পরিবর্তন করতে চান তবে সংগ্রহের একটি অনুলিপির উপর পুনরাবৃত্তি করা সাধারণত নিরাপদ।

উপসংহার

ইটারেটর প্রোটোকল, এর সাধারণ `__iter__` এবং `__next__` মেথডগুলির সাথে, পাইথনে ইটারেশনের ভিত্তি। এটি ভাষার নকশার দর্শনের একটি প্রমাণ: সরল, সামঞ্জস্যপূর্ণ ইন্টারফেসগুলির পক্ষে যা শক্তিশালী এবং জটিল আচরণ সক্ষম করে। ক্রমিক ডেটা অ্যাক্সেসের জন্য একটি সার্বজনীন চুক্তি সরবরাহ করে, প্রোটোকলটি `for` লুপ, কমপ্রিহেনশন এবং অগণিত অন্যান্য সরঞ্জামগুলিকে নির্বিঘ্নে কাজ করার অনুমতি দেয় যে কোনও অবজেক্ট তার ভাষা বলতে পছন্দ করে।

এই প্রোটোকলটি আয়ত্ত করে, আপনি আপনার নিজস্ব ক্রম-সদৃশ অবজেক্ট তৈরি করার ক্ষমতা আনলক করেছেন যা পাইথন ইকোসিস্টেমে প্রথম শ্রেণীর নাগরিক। আপনি এখন এমন ক্লাস লিখতে পারেন যা ডেটা অলসভাবে প্রক্রিয়াকরণের মাধ্যমে আরও মেমরি-সাশ্রয়ী, স্ট্যান্ডার্ড পাইথন সিনট্যাক্সের সাথে পরিষ্কারভাবে সংহত করে আরও স্বজ্ঞাত এবং শেষ পর্যন্ত আরও শক্তিশালী। পরবর্তী সময়ে আপনি যখন একটি `for` লুপ লিখবেন, তখন পৃষ্ঠের ঠিক নীচে ঘটছে এমন `__iter__` এবং `__next__` এর মার্জিত নৃত্যকে উপলব্ধি করতে কিছুক্ষণ সময় নিন।